import { defineStore } from 'pinia';
import request from '@/utils/request';

export const useLanguageStore = defineStore('language', {
  state: () => ({
    currentLang: 'zh-cn', // 默认语言
    langVersion: '1.0.1', // 语言版本号
    langContent: {}, // 语言内容
    // 缓存内容对象，按语言代码存储
    cachedContent: {
      'zh-cn': null,
      'en-us': null, 
      'ja-jp': null,
      'be-by': null
    },
    supportedLangs: [
      { code: 'zh-cn', name: '中文' },
      { code: 'en-us', name: 'English' },
      { code: 'ja-jp', name: '日本語' },
      { code: 'be-by', name: 'Беларуская' }
    ],
    isLoading: false,
    isInitialized: false, // 新增：标记是否已初始化完成
    serverVersion: null // 新增：缓存服务器版本，避免重复请求
  }),
  
  getters: {
    // 获取当前语言
    getCurrentLang: (state) => state.currentLang,
    
    // 获取语言版本号
    getLangVersion: (state) => state.langVersion,
    
    // 获取支持的语言列表
    getSupportedLangs: (state) => state.supportedLangs,
    
    // 获取当前语言的缓存内容
    getCurrentLangCache: (state) => state.cachedContent[state.currentLang],
    
    // 获取初始化状态
    getIsInitialized: (state) => state.isInitialized,
    
    // 翻译函数
    t: (state) => (key) => {
      return state.langContent[key] || key;
    }
  },
  
  actions: {
    // 初始化语言
    async initLanguage() {
      try {
        this.isLoading = true;
        console.log('开始初始化语言，当前语言：', this.currentLang, '缓存状态：', this.cachedContent);
        
        // 如果没有语言设置，则使用浏览器语言
        if (!this.currentLang) {
          const browserLang = navigator.language.toLowerCase();
          if (browserLang.includes('zh')) {
            this.currentLang = 'zh-cn';
          } else if (browserLang.includes('en')) {
            this.currentLang = 'en-us';
          } else if (browserLang.includes('ja')) {
            this.currentLang = 'ja-jp';
          } else if (browserLang.includes('be')) {
            this.currentLang = 'be-by';
          }
        }
        
        // 每次初始化都检查服务器版本
        await this.fetchServerVersion();
        
        // 加载语言内容
        await this.loadLanguageContent();
        
        this.isInitialized = true;
        console.log('语言初始化完成');
      } catch (error) {
        console.error('语言初始化失败:', error);
        // 即使失败也标记为已初始化，避免无限重试
        this.isInitialized = true;
      } finally {
        this.isLoading = false;
      }
    },
    
    // 获取服务器版本（每次刷新都检查）
    async fetchServerVersion() {
      try {
        console.log('检查服务器语言版本...');
        const versionResponse = await request({
          url: '/v6/language/getVersion',
          method: 'get',
          params: { lang: 'zh-cn' } // 使用主语言获取版本
        });
        
        if (versionResponse.code === 200) {
          const newServerVersion = versionResponse.data.version;
          console.log('服务器版本:', newServerVersion, '当前缓存版本:', this.serverVersion);
          
          // 如果版本发生变化，清空所有缓存
          if (this.serverVersion && this.serverVersion !== newServerVersion) {
            console.log('检测到版本更新，清空所有语言缓存');
            for (const lang of Object.keys(this.cachedContent)) {
              this.cachedContent[lang] = null;
            }
          }
          
          this.serverVersion = newServerVersion;
          return this.serverVersion;
        }
      } catch (error) {
        console.error('获取服务器版本失败:', error);
      }
      return null;
    },
    
    // 加载语言内容，优先使用缓存
    async loadLanguageContent() {
      try {
        // 检查当前语言的缓存内容
        const currentCache = this.cachedContent[this.currentLang];
        
        // 如果有缓存且版本一致，使用缓存内容
        if (currentCache && this.serverVersion && currentCache.version === this.serverVersion) {
          this.langContent = currentCache.content;
          this.langVersion = currentCache.version;
          console.log('使用缓存的语言内容:', this.currentLang, '版本:', this.langVersion);
        } else {
          // 无缓存或版本不一致，重新加载内容
          if (currentCache) {
            console.log('版本不一致，重新加载语言内容', '缓存版本:', currentCache.version, '服务器版本:', this.serverVersion);
          } else {
            console.log('无缓存，加载语言内容:', this.currentLang);
          }
          await this.fetchLanguageContent(this.serverVersion);
        }
      } catch (error) {
        console.error('加载语言内容失败:', error);
        // 如果有缓存使用缓存，无缓存则尝试直接加载
        const currentCache = this.cachedContent[this.currentLang];
        if (currentCache) {
          this.langContent = currentCache.content;
          this.langVersion = currentCache.version;
          console.log('错误恢复: 使用缓存的语言内容:', this.currentLang);
        } else {
          // 如果完全无缓存，尝试直接加载内容
          try {
            await this.fetchLanguageContent();
          } catch (e) {
            console.error('无缓存且加载失败，使用默认语言内容');
            this.langContent = {}; // 空对象作为默认值
          }
        }
      }
    },
    
    // 获取语言内容
    async fetchLanguageContent(serverVersion) {
      try {
        console.log('开始获取语言内容:', this.currentLang);
        
        const response = await request({
          url: '/v6/language/getContent',
          method: 'get',
          params: { lang: this.currentLang }
        });
        
        console.log('语言内容返回数据:', response.data);
        
        // 适应不同的响应结构
        let content, version;
        
        // 如果是带 code 的标准响应结构
        if (response.data && response.code === 200 && response.data) {
          content = response.data.content;
          version = serverVersion || response.data.version;
          console.log('使用标准响应结构');
        }
        // 如果直接返回内容对象
        else if (response.data && response.data.content) {
          content = response.data.content;
          version = serverVersion || response.data.version;
          console.log('使用直接响应结构');
        }
        
        if (content) {
          this.langContent = content;
          this.langVersion = version;
          console.log('语言内容加载成功:', this.currentLang, '数据结构类型:', typeof content);
          
          // 更新缓存 - 确保不为空对象
          if (Object.keys(content).length > 0) {
            this.cachedContent[this.currentLang] = {
              content: content,
              version: version,
              timestamp: Date.now()
            };
            console.log('更新语言内容缓存成功:', this.currentLang, '版本:', version);
          } else {
            console.error('获取到的语言内容为空对象，不更新缓存');
          }
        } else {
          console.error('无法从响应中提取语言内容数据:', response.data);
        }
      } catch (error) {
        console.error('获取语言内容失败:', error);
        throw error;
      }
    },
    
    
    // 切换语言（前后端分离优化版本）
    async switchLanguage(lang) {
      if (this.currentLang === lang) return;
      
      try {
        this.isLoading = true;
        console.log('开始切换语言从', this.currentLang, '到', lang);
        
        // 立即切换前端语言状态
        const oldLang = this.currentLang;
        this.currentLang = lang;
        
        // 立即加载新语言内容
        try {
          await this.loadLanguageContent();
          console.log('前端语言切换完成:', lang);
        } catch (contentError) {
          console.error('加载语言内容错误:', contentError);
          // 如果加载失败，回滚语言设置
          this.currentLang = oldLang;
          throw contentError;
        }
        
        // 异步通知后端（不阻塞前端切换）
        this.notifyBackendLanguageChange(lang).catch(error => {
          console.warn('后端语言切换通知失败（不影响前端）:', error);
        });
        
      } catch (error) {
        console.error('切换语言失败:', error);
        throw error;
      } finally {
        this.isLoading = false;
      }
    },
    
    // 异步通知后端语言变更
    async notifyBackendLanguageChange(lang) {
      try {
        const response = await request({
          url: '/v6/language/switchLang',
          method: 'post',
          data: { lang }
        });
        
        console.log('后端语言切换响应:', response);
        return response;
      } catch (error) {
        console.warn('后端语言切换失败:', error);
        // 不抛出错误，避免影响前端体验
        return null;
      }
    },
    
    // 获取支持的语言列表
    async fetchSupportedLangs() {
      try {
        const response = await request({
          url: '/v6/language/getLangList',
          method: 'get'
        });
        
        if (response.code === 200) {
          this.supportedLangs = response.data.list;
        }
      } catch (error) {
        console.error('获取支持的语言列表失败:', error);
      }
    }
  },
  
  // 持久化存储
  persist: {
    enabled: true,
    strategies: [
      {
        key: 'language_store',
        storage: localStorage,
        paths: ['currentLang', 'cachedContent'], // 不持久化 isInitialized 和 serverVersion
        beforeRestore: (ctx) => {
          console.log('语言存储恢复前状态:', ctx);
        },
        afterRestore: (ctx) => {
          console.log('语言存储恢复后状态:', ctx);
          // 恢复后重置状态，确保每次刷新都会重新检查版本
          ctx.store.isInitialized = false;
          ctx.store.serverVersion = null;
          ctx.store.isLoading = false;
        }
      }
    ]
  }
});
